﻿# TODO: Translation finish &updated at 2014-04-09 

# game/tutorial_atl.rpy:187
translate Chinese_Simplified tutorial_positions_a09a3fd1:

    # e "In this tutorial, I'll teach you how Ren'Py positions things on the screen. But before that, let's learn a little bit about how Python handles numbers."
    e "在这个教程中，我会教你Ren'Py 如何定位东西到屏幕。但是在此之前，请学习一下Python如何处理数值。"

# game/tutorial_atl.rpy:189
translate Chinese_Simplified tutorial_positions_ba39aabc:

    # e "There are two main kinds of numbers in Python: integers and floating point numbers. An integer consists entirely of digits, while a floating point number has a decimal point."
    e "在Python中有两类主要的数值：integers （整型）和 floating point（浮点型）数值。整形完全就是一个数字，而浮点型是带有小数点的数字。 "

# game/tutorial_atl.rpy:191
translate Chinese_Simplified tutorial_positions_a60b775d:

    # e "For example, 100 is an integer, while 0.5 is a floating point number, or float for short. In this system, there are two zeros: 0 is an integer, and 0.0 is a float."
    e "举个例子，100是一个整型，而0.5是一个浮点型，或者短型浮点。在这个系统中有两个零：0是一个整型，0.0是浮点型。"

# game/tutorial_atl.rpy:193
translate Chinese_Simplified tutorial_positions_7f1a560c:

    # e "Ren'Py uses integers to represent absolute coordinates, and floats to represent fractions of an area with known size."
    e "Ren'Py使用整型来表示绝对坐标，使用浮点型来表示已知大小的比率。 "

# game/tutorial_atl.rpy:195
translate Chinese_Simplified tutorial_positions_8e7d3e52:

    # e "When we're positioning something, the area is usually the entire screen."
    e "当我们要定位一些东西，这个区域通常就是整个屏幕。"

# game/tutorial_atl.rpy:197
translate Chinese_Simplified tutorial_positions_fdcf9d8b:

    # e "Let me get out of the way, and I'll show you where some positions are."
    e "让我避开一下，以便展示一些定位的内容。"

# game/tutorial_atl.rpy:211
translate Chinese_Simplified tutorial_positions_76d7a5bf:

    # e "The origin is the upper-left corner of the screen. That's where the x position (xpos) and the y position (ypos) are both zero."
    e "原点就是屏幕的左上角。哪里x坐标 (xpos)和y坐标(ypos)均为零"

# game/tutorial_atl.rpy:217
translate Chinese_Simplified tutorial_positions_be14c7c3:

    # e "When we increase xpos, we move to the right. So here's an xpos of .5, meaning half the width across the screen."
    e "当我们增加xpos，我们向右移动。而这里是xpos为 .5，就意味着屏幕宽度的一半。"

# game/tutorial_atl.rpy:222
translate Chinese_Simplified tutorial_positions_9b91be6c:

    # e "Increasing xpos to 1.0 moves us to the right-hand border of the screen."
    e "增加xpos到1.0移动到屏幕右手边的边界上。"

# game/tutorial_atl.rpy:228
translate Chinese_Simplified tutorial_positions_80be064f:

    # e "We can also use an absolute xpos, which is given in an absolute number of pixels from the left side of the screen. For example, since this window is 800 pixels across, using an xpos of 400 will return the target to the center of the top row."
    e "我们还可以使用绝对坐标的xpos，给予一个从屏幕左边数来的绝对像素数值。举个例子，该窗口水平是800像素，使xpos为400来将目标再次返回第一列的中央。"

# game/tutorial_atl.rpy:230
translate Chinese_Simplified tutorial_positions_c4d18c0a:

    # e "The y-axis position, or ypos works the same way. Right now, we have a ypos of 0.0."
    e "y轴或ypos也是同样的工作原理，现在ypos是0.0。"

# game/tutorial_atl.rpy:236
translate Chinese_Simplified tutorial_positions_16933a61:

    # e "Here's a ypos of 0.5."
    e "这里的ypos为0.5。"

# game/tutorial_atl.rpy:241
translate Chinese_Simplified tutorial_positions_6eb36777:

    # e "A ypos of 1.0 specifies a position at the bottom of the screen. If you look carefully, you can see the position indicator spinning below the text window."
    e "ypos为1.0表示屏幕最下方的位置。如果你仔细地看，你可以看到定位指示器在文本窗口后方旋转着（根本停不下来）。"

# game/tutorial_atl.rpy:243
translate Chinese_Simplified tutorial_positions_a423050f:

    # e "Like xpos, ypos can also be an integer. In this case, ypos would give the total number of pixels from the top of the screen."
    e "跟xpos一样，ypos也可以是一个整型数。在这个情况下，ypos可以赋予从屏幕顶部开始往下的像素数量。"

# game/tutorial_atl.rpy:249
translate Chinese_Simplified tutorial_positions_bc7a809a:

    # e "Can you guess where this position is, relative to the screen?" nointeract
    e "你可以猜猜这个位置相对于屏幕的坐标吗？" nointeract

# game/tutorial_atl.rpy:255
translate Chinese_Simplified tutorial_positions_6f926e18:

    # e "Sorry, that's wrong. The xpos is .75, and the ypos is .25."
    e "对不起，那个错了。这个xpos 是 .75而ypos 是 .25。"

# game/tutorial_atl.rpy:257
translate Chinese_Simplified tutorial_positions_5d5feb98:

    # e "In other words, it's 75%% of the way from the left side, and 25%% of the way from the top."
    e "换而言之，它就是从左边的75%，从顶部的25%的位置。"

# game/tutorial_atl.rpy:261
translate Chinese_Simplified tutorial_positions_77b45218:

    # e "Good job! You got that position right."
    e "干得好！你说对了位置。"

# game/tutorial_atl.rpy:265
translate Chinese_Simplified tutorial_positions_6f926e18_1:

    # e "Sorry, that's wrong. The xpos is .75, and the ypos is .25."
    e "对不起，那个错了。这个xpos 是 .75而ypos 是 .25。"

# game/tutorial_atl.rpy:267
translate Chinese_Simplified tutorial_positions_5d5feb98_1:

    # e "In other words, it's 75%% of the way from the left side, and 25%% of the way from the top."
    e "换而言之，它就是从左边的75%，从顶部的25%的位置。"

# game/tutorial_atl.rpy:281
translate Chinese_Simplified tutorial_positions_e4380a83:

    # e "The second position we care about is the anchor. The anchor is a spot on the thing being positioned."
    e "第二个我们要关注的定位就是锚点（anchor）。锚点（anchor）就是一个位置的定位标。"

# game/tutorial_atl.rpy:283
translate Chinese_Simplified tutorial_positions_d1db1246:

    # e "For example, here we have an xanchor of 0.0 and a yanchor of 0.0. It's in the upper-left corner of the logo image."
    e "举个例子，这里我们有一个锚点是xanchor为0.0和yanchor为0.0来确定在这个logo图像的左上角。"

# game/tutorial_atl.rpy:288
translate Chinese_Simplified tutorial_positions_6056873f:

    # e "When we increase the xanchor to 1.0, the anchor moves to the right corner of the image."
    e "等我们增加xanchor 为1.0，则锚点一道图像的右边角落。"

# game/tutorial_atl.rpy:293
translate Chinese_Simplified tutorial_positions_7cdb8dcc:

    # e "Similarly, when both xanchor and yanchor are 1.0, the anchor is the bottom-right corner."
    e "类似地，我们让xanchor 和 yanchor都设为1.0，则锚点就是右下角了。"

# game/tutorial_atl.rpy:301
translate Chinese_Simplified tutorial_positions_03a07da8:

    # e "To place an image on the screen, we need both the position and the anchor."
    e "要放置一个图片到屏幕，我们都需要定位和锚点这两个要素。"

# game/tutorial_atl.rpy:309
translate Chinese_Simplified tutorial_positions_8945054f:

    # e "We then line them up, so that both the position and anchor are at the same point on the screen."
    e "我们接着把它们排在同一直线上，然后让定位和锚点在屏幕的同一个位置上。"

# game/tutorial_atl.rpy:319
translate Chinese_Simplified tutorial_positions_2b184a93:

    # e "When we place both in the upper-left corner, the image moves to the upper-left corner of the screen."
    e "当我们将其放在左上角时，图片就会移到屏幕的左上角。"

# game/tutorial_atl.rpy:328
translate Chinese_Simplified tutorial_positions_5aac4f3f:

    # e "With the right combination of position and anchor, any place on the screen can be specified, without even knowing the size of the image."
    e "通过正确地组合定位和锚点，可以设定屏幕上任意的位置，而不必知道图像的大小。"

# game/tutorial_atl.rpy:340
translate Chinese_Simplified tutorial_positions_3b59b797:

    # e "It's often useful to set xpos and xanchor to the same value. We call that xalign, and it gives a fractional position on the screen."
    e "一般我们将xpos和xanchor设定为相同的值。我们成为xalign（x轴对齐），给予一个屏幕的分数值。"

# game/tutorial_atl.rpy:345
translate Chinese_Simplified tutorial_positions_b8ebf9fe:

    # e "For example, when we set xalign to 0.0, things are aligned to the left side of the screen."
    e "举个例子，当我们设定xalign（x轴对齐）为0.0，则东西就会对齐到屏幕的左边。"

# game/tutorial_atl.rpy:350
translate Chinese_Simplified tutorial_positions_8ce35d52:

    # e "When we set it to 1.0, then we're aligned to the right side of the screen."
    e "如果设定为1.0，则就会对齐到屏幕的右边。"

# game/tutorial_atl.rpy:355
translate Chinese_Simplified tutorial_positions_6745825f:

    # e "And when we set it to 0.5, we're back to the center of the screen."
    e "当我们设为0.5时，我们就返回到屏幕的中央。"

# game/tutorial_atl.rpy:357
translate Chinese_Simplified tutorial_positions_64428a07:

    # e "Setting yalign is similar, except along the y-axis."
    e "yalign（y轴对齐）也可以相似地设定，只不过是作用于y轴而已。"

# game/tutorial_atl.rpy:359
translate Chinese_Simplified tutorial_positions_cfb77d42:

    # e "Remember that xalign is just setting xpos and xanchor to the same value, and yalign is just setting ypos and yanchor to the same value."
    e "记住xalign只不过设定xpos 和 xanchor为相同的值，而yalign也只是设定 ypos 和 yanchor为相同的值。"

# game/tutorial_atl.rpy:366
translate Chinese_Simplified tutorial_positions_0f4ca2b6:

    # e "Once you understand positions, you can use transformations to move things around the Ren'Py screen."
    e "当你明白了定位后，你就可以使用转移（transformations）来讲东西在Ren'Py屏幕中移来移去（根本停不下来了）。"

# game/tutorial_atl.rpy:373
translate Chinese_Simplified tutorial_atl_a1cc1bff:

    # e "While showing static images is often enough for most games, occasionally we'll want to change images, or move them around the screen."
    e "对于大多数游戏中显示静态图像来说，已经非常足够了。我们很少会想去改变图像，或者在屏幕上移动图像。"

# game/tutorial_atl.rpy:375
translate Chinese_Simplified tutorial_atl_81dbb8f2:

    # e "We call this a Transform, and it's what ATL, Ren'Py's Animation and Transformation Language, is for."
    e "我们称其为Transform（变换），那就是ATL，Ren'Py的动画与变换语言（Animation and Transformation Language）的工作。"

# game/tutorial_atl.rpy:383
translate Chinese_Simplified tutorial_atl_65badef3:

    # e "But first, let's have... a Gratuitous Rock Concert!"
    e "但是首先，让我们来一个……免费摇滚音乐会！（让我们根本停不下来吧！）"

# game/tutorial_atl.rpy:391
translate Chinese_Simplified tutorial_atl_3ccfe2ac:

    # e "That was a lot of work, and before you can do that, we'll need to start with the basics of using ATL."
    e "那还需要费一番功夫才能做到那样，那么我们就开始一些使用ATL的基础吧。"

# game/tutorial_atl.rpy:393
translate Chinese_Simplified tutorial_atl_1f22f875:

    # e "There are currently three places where ATL can be used in Ren'Py."
    e "现在来说在Ren'Py中有三个地方会用到ATL。"

# game/tutorial_atl.rpy:397
translate Chinese_Simplified tutorial_atl_fd036bdf:

    # e "The first place ATL can be used is as part of an image statement. Instead of a displayable, an image may be defined as a block of ATL code."
    e "第一个用到ATL的就是作为图像的声明，或者说是可视化对象，一个图像对象（image）可能是由一个块的ATL代码定义。"

# game/tutorial_atl.rpy:399
translate Chinese_Simplified tutorial_atl_7cad2ab9:

    # e "When used in this way, we have to be sure that ATL includes one or more displayables to actually show."
    e "当这样使用时，我们要确保ATL已经包含一个或更多可视化的用于真实显示的对象。"

# game/tutorial_atl.rpy:403
translate Chinese_Simplified tutorial_atl_c78b2a1e:

    # e "The second way is through the use of the transform statement. This assigns the ATL block to a python variable, allowing it to be used in at clauses and inside other transforms."
    e "第二个就是在变换声明时使用。这个分配了ATL块为python变量，让其可以作为参数条件地在其他变换中可以使用。"

# game/tutorial_atl.rpy:407
translate Chinese_Simplified tutorial_atl_da7a7759:

    # e "Finally, an ATL block can be used as part of a show statement, instead of the at clause."
    e "最后，ATL快还可以作为显示声明的一部分，作为参数条件。"

# game/tutorial_atl.rpy:411
translate Chinese_Simplified tutorial_atl_c21bc1d1:

    # e "The key to ATL is what we call composeability. ATL is made up of relatively simple commands, which can be combined together to create complicated transforms."
    e "ATL的关键就是创造力。ATL组成了相当简单的命令，可以组合起来创造一些复杂的变换效果。"

# game/tutorial_atl.rpy:413
translate Chinese_Simplified tutorial_atl_ed82983f:

    # e "Before I explain how ATL works, let me explain what animation and transformation are."
    e "在我交待ATL工作模式前，让我来解释一下什么叫做动画和变换吧。"

# game/tutorial_atl.rpy:418
translate Chinese_Simplified tutorial_atl_2807adff:

    # e "Animation is when the displayable being shown changes. For example, right now I am changing my expression."
    e "动画就是可视化对象可以显示变化。举个例子，现在我改变了我的表情。"

# game/tutorial_atl.rpy:445
translate Chinese_Simplified tutorial_atl_3eec202b:

    # e "Transformation involves moving or distorting an image. This includes placing it on the screen, zooming it in and out, rotating it, and changing its opacity."
    e "变换（Transformation）包含了图像的移动和变形。这包括放置到屏幕，缩放，旋转和改变不透明度。"

# game/tutorial_atl.rpy:453
translate Chinese_Simplified tutorial_atl_fbc9bf83:

    # e "To introduce ATL, let's start by looking at at a simple animation. Here's one that consists of five lines of ATL code, contained within an image statement."
    e "要介绍ATL，就让我们看看一个动画样本。这里是一个使用五行的ATL代码做成的，包含了一个图像声明。"

# game/tutorial_atl.rpy:455
translate Chinese_Simplified tutorial_atl_12c839ee:

    # e "In ATL, to change a displayable, simply mention it on a line of ATL code. Here, we're switching back and forth between two images."
    e "ATL中，要改变一个可视化对象，简单地在ATL代码行中引用就可以。这里我们是在两个图像之间切换。"

# game/tutorial_atl.rpy:457
translate Chinese_Simplified tutorial_atl_c671ed7d:

    # e "Since we're defining an image, the first line of ATL has to name a displayable. Otherwise, there would be nothing to show."
    e "一旦我们定义了一个图像，第一行的ATL就是命名可视化对象。否则的话讲不会有东西显示出来。"

# game/tutorial_atl.rpy:459
translate Chinese_Simplified tutorial_atl_99386181:

    # e "The second and fourth lines are pause statements, which cause ATL to wait half of a second each before continuing. That's how we give the delay between images."
    e "第二和第四行是pause声明，就是一个ATL语句让其暂停半秒然后继续。这就是两个图像之间的延时。"

# game/tutorial_atl.rpy:461
translate Chinese_Simplified tutorial_atl_60f2a5e8:

    # e "The final line is a repeat statement. This causes the current block of ATL to be restarted. You can only have one repeat statement per block."
    e "最后一行就是一个repeat声明。这个让当前整个ATL块重头开始。每一个语块只能有一个repeat声明。"

# game/tutorial_atl.rpy:466
translate Chinese_Simplified tutorial_atl_146cf4c4:

    # e "If we were to write repeat 2 instead, the animation would loop twice, then stop."
    e "如果我写repeat 2的话，则动画就会循环两次，然后停止。"

# game/tutorial_atl.rpy:471
translate Chinese_Simplified tutorial_atl_d90b1838:

    # e "Omitting the repeat statement means that the animation stops once we reach the end of the block of ATL code."
    e "省略（Omitting）repaeat（重复）声明意味着动画动画到达ATL代码块的末尾则就会结束。"

# game/tutorial_atl.rpy:476
translate Chinese_Simplified tutorial_atl_e5872360:

    # e "By default, displayables are replaced instantaneously. We can also use a with clause to give a transition between displayables."
    e "默认的，可视化对象会瞬间取代。我们可以使用一个参数条件来让其设定可视化对象的变换。"

# game/tutorial_atl.rpy:483
translate Chinese_Simplified tutorial_atl_a7f8ed01:

    # e "Now, let's move on to see how we can use ATL to transform an image. We'll start off by seeing what we can do to position images on the screen."
    e "现在，让我们过来看看ATL如何变换一个图像。我们首先看到的是将一个图片定位在屏幕上。"

# game/tutorial_atl.rpy:492
translate Chinese_Simplified tutorial_atl_24501213:

    # e "Perhaps the simplest thing we can do is to position the images on the screen. This can be done by simply giving the names of the transform properties, each followed by the value."
    e "也许我们可以做的最简单的事情就是将图片放置在屏幕上。我们仅需简单地将变换属性的名字，并跟随一个值。"

# game/tutorial_atl.rpy:497
translate Chinese_Simplified tutorial_atl_43516492:

    # e "With a few more statements, we can move things around on the screen."
    e "通过更多的声明，我们可以让东西在屏幕上移动。"

# game/tutorial_atl.rpy:499
translate Chinese_Simplified tutorial_atl_8b053b5a:

    # e "This code starts the image off at the top-right of the screen, and waits a second."
    e "该代码将图像显示在屏幕右上角，并等待1秒钟。"

# game/tutorial_atl.rpy:501
translate Chinese_Simplified tutorial_atl_d7fc5372:

    # e "It then moves it to the left side, waits another second, and repeats."
    e "然后将它移到左边，等待1秒钟，然后重复。"

# game/tutorial_atl.rpy:503
translate Chinese_Simplified tutorial_atl_7650ec09:

    # e "The pause and repeat statements are the same statements we used in our animations. They work throughout ATL code."
    e " pause（暂停）和repeat（重复）声明在动画当中都是一样的声明。他们都作为ATL代码工作。"

# game/tutorial_atl.rpy:508
translate Chinese_Simplified tutorial_atl_d3416d4f:

    # e "Having the image jump around on the screen isn't all that useful. That's why ATL has the interpolation statement."
    e "将图片在屏幕上跳来跳去虽然不是很有用。所以ATL有一个interpolation（补间）声明。"

# game/tutorial_atl.rpy:510
translate Chinese_Simplified tutorial_atl_4e7512ec:

    # e "The interpolation statement allows you to smoothly vary the value of a transform property, from an old to a new value."
    e "interpolation（补间）声明允许你圆滑变化变换属性的值，从旧值到新值。"

# game/tutorial_atl.rpy:512
translate Chinese_Simplified tutorial_atl_685eeeaa:

    # e "Here, we have an interpolation statement on the second ATL line. It starts off with the name of a time function, in this case linear."
    e "这里，我们有一个interpolation（补间）声明在第二行的ATL中。有一个名字开始的时间函数，这里是linear（线性）"

# game/tutorial_atl.rpy:514
translate Chinese_Simplified tutorial_atl_c5cb49de:

    # e "That's followed by an amount of time, in this case three seconds. It ends with a list of properties, each followed by its new value."
    e "紧接着的是一个时间，在这里是3秒。以一系列的参数结束，那就是新的值。"

# game/tutorial_atl.rpy:516
translate Chinese_Simplified tutorial_atl_72d47fb6:

    # e "The old value is the value of the transform property at the start of the statement. By interpolating the property over time, we can change things on the screen."
    e "旧值就是变换属性声明前面的值。通过interpolation（补间）属性来设定时间，我们可以改变屏幕上的东西。"

# game/tutorial_atl.rpy:526
translate Chinese_Simplified tutorial_atl_2958f397:

    # e "ATL supports more complicated move types, like circle and spline motion. But I won't be showing those here."
    e "ATL提供更多高级的移动类型，像 circle （圆）和 spline（曲线）。但是我不想在这里展示了。"

# game/tutorial_atl.rpy:528
translate Chinese_Simplified tutorial_atl_4a02c8d8:

    # e "Next, let's take a look at some of the transform properties that we can change using ATL."
    e "接着，让我们看看一些可以使用ATL来改变的变换属性。"

# game/tutorial_atl.rpy:543
translate Chinese_Simplified tutorial_atl_821fcb91:

    # e "We've already seen the position properties. Along with xalign and yalign, we support the xpos, ypos, xanchor, and yanchor properties."
    e "我们已经看过定位属性了。伴随着xalign 和 yalign，我们提供xpos, ypos, xanchor, 和 yanchor属性。"

# game/tutorial_atl.rpy:558
translate Chinese_Simplified tutorial_atl_cca5082b:

    # e "We can perform a pan by using xpos and ypos to position images off of the screen."
    e "我们可以使 xpos 和 ypos来显示的一个图像在屏幕外的一个容器。"

# game/tutorial_atl.rpy:560
translate Chinese_Simplified tutorial_atl_0394dd50:

    # e "This usually means giving them negative positions."
    e "这个我们通常给予它们负值的定位。"

# game/tutorial_atl.rpy:577
translate Chinese_Simplified tutorial_atl_2624662e:

    # e "The zoom property lets us scale the displayable by a factor, making it bigger and smaller. For best results, zoom should always be greater than 0.5."
    e "缩放属性让我们通过一个因子缩放可视化对象，让其变大变小。为了得到好的效果，缩放因子zoom通常都比0.5大。"

# game/tutorial_atl.rpy:591
translate Chinese_Simplified tutorial_atl_b6527546:

    # e "The xzoom and yzoom properties allow the displayable to be scaled in the X and Y directions independently."
    e "xzoom 和 yzoom属性让可视化对象按照X和Y轴方向缩放。"

# game/tutorial_atl.rpy:602
translate Chinese_Simplified tutorial_atl_9fe238de:

    # e "The size property can be used to set a size, in pixels, that the displayable is scaled to."
    e "size属性可以重新设定大小，可视化对象会自动按像素缩放。"

# game/tutorial_atl.rpy:617
translate Chinese_Simplified tutorial_atl_6b982a23:

    # e "The alpha property allows us to vary the opacity of a displayable. This can make it appear and disappear."
    e "alpha属性让我们改变可视化的不透明度。这个可以让其显示或者不显示。"

# game/tutorial_atl.rpy:631
translate Chinese_Simplified tutorial_atl_60d6d9f3:

    # e "The rotate property lets us rotate a displayable."
    e "rotate属性让你旋转一个可视化对象。"

# game/tutorial_atl.rpy:633
translate Chinese_Simplified tutorial_atl_898a138a:

    # e "Since rotation can change the size, usually you'll want to set xanchor and yanchor to 0.5 when positioning a rotated displayable."
    e "旋转也可以改变大小，通常你需要定位时将可视化对象的xanchor 和 yanchor设为0.5。"

# game/tutorial_atl.rpy:644
translate Chinese_Simplified tutorial_atl_207b7fc8:

    # e "The crop property crops a rectangle out of a displayable, showing only part of it."
    e "crop属性修建一个可视化对象，仅仅显示其中的一部分。"

# game/tutorial_atl.rpy:658
translate Chinese_Simplified tutorial_atl_ebb84988:

    # e "When used together, they can be used to focus in on specific parts of an image."
    e "一起使用，他们可以用于聚焦图像的某一部分。"

# game/tutorial_atl.rpy:664
translate Chinese_Simplified tutorial_atl_d08fe8d9:

    # e "Apart from displayables, pause, interpolation, and repeat, there are a few other statements we can use as part of ATL."
    e "且不说可视化对象，pause（暂停）interpolation（插值）和 repeat（重复），就已经有相当多的其他声明我们可以作为ATL来使用。"

# game/tutorial_atl.rpy:678
translate Chinese_Simplified tutorial_atl_db6302bd:

    # e "When we create an ATL transform using the transform statement, we can use that transform as an ATL statement."
    e "当我们使用transform（变换）声明创造了一个ATL变换，我们可以使用那个transform（变换）作为一个ATL声明。"

# game/tutorial_atl.rpy:680
translate Chinese_Simplified tutorial_atl_785911cf:

    # e "Since the default positions are also transforms, this means that we can use left, right, and center inside of an ATL block."
    e "由于设定默认的定位也是变换，这就意味着我们可以在ATL块中使用left，right，center。"

# game/tutorial_atl.rpy:698
translate Chinese_Simplified tutorial_atl_331126c1:

    # e "Here, we have two new statements. The block statement allows you to include a block of ATL code. Since the repeat statement applies to blocks, this lets you repeat only part of an ATL transform."
    e "这里我们有两个声明。块声明允许我们包含一整块的ATL代码。当repeat声明应用于块中，这就让你重复这部分的ATL变换。"

# game/tutorial_atl.rpy:700
translate Chinese_Simplified tutorial_atl_24f67b67:

    # e "We also have the time statement, which runs after the given number of seconds have elapsed from the start of the block. It will run even if another statement is running, stopping the other statement."
    e "你还可以带time声明，运行给出的数值的秒数的时间然后开始块。即便其他的声明还在运行它也会运行，并停止其他的声明。"

# game/tutorial_atl.rpy:702
translate Chinese_Simplified tutorial_atl_30dc0008:

    # e "So this code will bounce the image back and forth for eleven and a half seconds, and then move back to the right side of the screen."
    e "所以这代码会来回反弹图像11秒半，然后回到屏幕的右边。"

# game/tutorial_atl.rpy:718
translate Chinese_Simplified tutorial_atl_f903bc3b:

    # e "The parallel statement lets us run two blocks of ATL code at the same time."
    e "parallel（并行）声明让我们同时运行两个块的ATL代码。"

# game/tutorial_atl.rpy:720
translate Chinese_Simplified tutorial_atl_5d0f8f9d:

    # e "Here, the top block move the image in the horizontal direction, and the bottom block moves it in the vertical direction. Since they're moving at different speeds, it looks like the image is bouncing on the screen."
    e "这里，顶层的块水平移动图像位置，而底层块垂直移动图像位置。由于其运行于不同的速度，所以看起来就像在屏幕里反弹一样。"

# game/tutorial_atl.rpy:737
translate Chinese_Simplified tutorial_atl_28a7d27e:

    # e "Finally, the choice statement makes Ren'Py randomly pick a block of ATL code. This allows you to add some variation as to what Ren'Py shows."
    e "最后，choice（选择）声明让Ren'Py随机地放置ATL代码块。这允许你添加一些变化来改变Ren'Py的显示。"

# game/tutorial_atl.rpy:743
translate Chinese_Simplified tutorial_atl_5fc8c0df:

    # e "This tutorial game has only scratched the surface of what you can do with ATL. For example, we haven't even covered the on and event statements. For more information, you might want to check out the ATL chapter in the reference manual."
    e "该教程游戏只是说了一点你可以用ATL做的皮毛功夫。举个例子，我们还没有涵盖on（触发）和event（事件）声明。要获取更多信息你可以查阅参考手册中的ATL章节。"

# game/tutorial_atl.rpy:747
translate Chinese_Simplified tutorial_atl_1358c6b4:

    # e "But for now, just remember that when it comes to animating and transforming, ATL is the hot new thing."
    e "但是现在呢，只需记住当需要动画和变换，ATL是一个最好的选择。"

translate Chinese_Simplified strings:

    # game/tutorial_atl.rpy:249
    old "xpos 1.0 ypos .5"
    new "xpos 1.0 ypos .5"

    # game/tutorial_atl.rpy:249
    old "xpos .75 ypos .25"
    new "xpos .75 ypos .25"

    # game/tutorial_atl.rpy:249
    old "xpos .25 ypos .33"
    new "xpos .25 ypos .33"

